import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * Description: Java集合类的方法复习
 */
public class Test {
    public static void main(String[] args) {
        mapTest();
    }

    // Map的练习
    public static void mapTest() {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "zhangsan");
        map.put(2, "lisi");
        map.put(3, "wangwu");
        map.put(4, "zhaoliu");
        String ret = map.get(2);
        System.out.println(map.remove(2));
        System.out.println(ret);
        Set<Integer> set = map.keySet();
        System.out.println(set);
        Set<Map.Entry<Integer, String>> set2 = map.entrySet();
        for (Map.Entry entry:set2) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
        System.out.println(map.containsValue("lisi"));
        System.out.println(map.containsKey(5));
        map.clear();
        System.out.println(map);
    }

    // PriorityQueue的练习
    public static void priorityQueueTest() {
        // 1. 创建大根堆，传入比较器，默认小根堆
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        // 堆的输入
        // 堆的元素插入是向上调整
        // 此时堆顶元素为1，堆中的顺序是1
        priorityQueue.offer(1);
        // 此时堆顶元素是2，堆中的顺序是2，1
        priorityQueue.offer(2);
        // 此时堆顶元素是3，堆中的顺序是3，1，2
        priorityQueue.offer(3);
        // 此时堆顶元素是4，堆中的顺序是4，3，2，1
        priorityQueue.offer(4);

        // 删除堆顶元素
//        int ret = priorityQueue.poll();
        // 获取堆顶元素
        int ret = priorityQueue.peek();
        System.out.println(priorityQueue.isEmpty());
        System.out.println(priorityQueue.size());
        System.out.println(ret);
        System.out.println(priorityQueue);

    }

    // Queue的练习，先进后出
    public static void queueTest() {
        // Queue只是一个接口，它的实现是通过LinkedList来实现的
//        Queue<Integer> queue = new LinkedList<>();
//        boolean flag = queue.isEmpty();
//        System.out.println(flag);
//        // 队列插入元素
//        queue.offer(1);
//        queue.offer(2);
//        queue.offer(3);
//        // System.out.println(queue);
//        // 删除队首元素
//        // int ret = queue.poll();
//        // 获取队首元素
//        int ret = queue.peek();
//        // 获取队列元素个数
//        int size = queue.size();
//        // 判断队列是否为空
//        flag = queue.isEmpty();
//        System.out.println(flag);
//        System.out.println(ret);
//        System.out.println(size);
//        System.out.println(queue);

        // 双端队列
        Deque<Integer> deque = new LinkedList<>();
        deque.offerFirst(1);
        deque.offerLast(2);
        deque.offerFirst(3);
        System.out.println(deque);
        // 删除，获取操作也都是在后面加上First或Last
    }

    // Stack的复习，先进先出
    public static void stackTest() {
        // 栈的创建
        Stack<Integer> stack = new Stack<>();
        // 入栈
        stack.push(1);
        stack.push(2);
        stack.push(3);
        // 出栈
        // int tmp = stack.pop();
        // 返回栈顶元素
        int tmp = stack.peek();
        // 返回栈中元素的个数
        int size = stack.size();
        // 判断栈是否为空
        boolean flag = stack.empty();
        System.out.println(tmp);
        System.out.println(size);
        System.out.println(flag);
        // 直接打印是按照栈底到栈顶打印
        System.out.println(stack);
    }

    // ArrayList与LinkedList的复习
    public static void listTest() {
        List<Integer> list = new ArrayList<>();
        // 尾插
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        // 插到index的位置
        list.add(0,100);
        // 删除index位置的元素
        list.remove(0);
        // 删除遇到的第一个o
        list.add(3);
        Integer i = 3;
        list.remove(i);
        // 获取下标index的元素
        // System.out.println(list.get(0));
        // 将下标index位置的元素值设为element
        list.set(1,5);
        // 清空
        // list.clear();
        // 判断o是否在线性表中
        // System.out.println(list.contains(1));
        // 返回第一个o所在的下标
        // System.out.println(list.indexOf(1));
        // 不存在就返回-1
        // System.out.println(list.indexOf(100));
        // 截取部分list，左闭右开
        List<Integer> list1 = list.subList(1,4);
        System.out.println(list1);
        System.out.println(list);
    }
}
